Android
Memory
Leaks

// Format: GC_REASON(GC_TYPE) freed K(Y%) paused Xms+Xms total Xms

I/art: GC_CONCURRENT(sticky) freed 4MB (31%), paused 1.5ms+0.5ms, total 18ms
// ✓ HEALTHY — Sticky CC fast path. Tiny pause. Lots freed.

I/art: GC_FOR_ALLOC(full) freed 512KB (2%), paused 120ms+45ms, total 165ms
// ⚠ WARNING — Allocator failed. Blocking GC ran synchronously on calling thread.
//             If that thread was Main — UI was frozen for 165ms.

I/art: Heap size=128MB, alloc=124MB, free=4MB (3%)
I/art: GC_BEFORE_OOM freed 256KB (0%), paused 348ms, total 350ms
// ✗ CRITICAL — Last-ditch GC. Freed almost nothing. OOM imminent.

E/art: Out of memory on a 8388616-byte allocation.
java.lang.OutOfMemoryError: Failed to allocate a 8388616 byte allocation
  with 1048576 free bytes and 4MB until OOM, max allowed footprint 134217728

// GC_REASON reference:
//   GC_CONCURRENT  — background GC, proactive, non-blocking
//   GC_FOR_ALLOC   — allocator failed, blocking on requesting thread ← worst
//   GC_EXPLICIT    — System.gc() was called — never do this in prod
//   GC_BEFORE_OOM  — last-ditch attempt, almost always followed by OOM
//   GC_HPROF_DUMP  — heap dump (LeakCanary triggers this)

// ANR in com.myapp — Input dispatching timed out

// ─── MAIN THREAD (tid=1) — your blocked UI thread ───
"main" prio=5 tid=1 WaitingForGcToComplete
  | state=S
  at java.lang.Object.wait!(Object.java:-2)
  at com.android.internal.os.BinderInternal.waitForGcToComplete  ← waiting for GC!
  at android.os.Binder.blockUntilThreadAvailable (Binder.java:...

// ─── GC THREAD — the cause ───
"HeapTaskDaemon" prio=5 tid=6 Runnable
  | state=R (running — running full Mark-Compact on 120MB bloated heap)
  at dalvik.system.VMRuntime.runFinalization

// What to look for in a GC-caused ANR:
//   "WaitingForGcToComplete" in main thread state
//   "HeapTaskDaemon" thread is Runnable (running GC)
//   Large heap size in the trace header
//   FinalizerDaemon backed up with many pending objects

val rt = Runtime.getRuntime()
val maxHeap   = rt.maxMemory()           // process heap limit e.g. 128 MB
val totalHeap = rt.totalMemory()         // current total (grows up to max)
val freeHeap  = rt.freeMemory()          // free within current total
val available = freeHeap + (maxHeap - totalHeap)  // true headroom

val am = getSystemService(ActivityManager::class.java)!!
val heapMB = am.memoryClass              // soft per-app limit for device tier

// System RAM pressure
val info = ActivityManager.MemoryInfo()
am.getMemoryInfo(info)
val lowMemory = info.lowMemory           // true = LMK is actively killing processes

// The rotation test — run this before and after rotating 5 times
// $ adb shell dumpsys meminfo com.myapp | grep "Java Heap"
// Java Heap PSS growing 20-50MB per rotation = confirmed leak

if (BuildConfig.DEBUG) {
    val pct = ((maxHeap - available) * 100.0 / maxHeap).toInt()
    Log.d("Heap", "$pct% used — ${available/1024/1024}MB free of ${maxHeap/1024/1024}MB")
}

object AnalyticsManager {
    var currentActivity: Activity? = null  // rotates once = 1 leaked Activity + full hierarchy
}
companion object {
    private var cachedView: View? = null  // View holds Context (Activity) → leak chain
}
class ImageLoader(val context: Context) {
    companion object {
        fun init(ctx: Context) = ImageLoader(ctx)  // accidentally passing Activity context
    }
}

object AnalyticsManager {
    private var ref: WeakReference<Activity>? = null
    fun attach(a: Activity) { ref = WeakReference(a) }
    fun detach() { ref = null }
}
fun init(ctx: Context) = ImageLoader(ctx.applicationContext)  // Application context, safe

class SplashActivity : AppCompatActivity() {
    inner class SplashHandler : Handler(Looper.getMainLooper()) {
        override fun handleMessage(msg: Message) { navigate() }  // holds SplashActivity
    }
    private val handler = SplashHandler()
}

// Modern: use lifecycleScope — automatically cancelled in onDestroy
private fun startTimer() {
    lifecycleScope.launch { delay(5000); navigate() }
}

@HiltViewModel
class GoodViewModel @Inject constructor(
    @ApplicationContext private val ctx: Context  // Application context, safe
) : ViewModel()

override fun onDestroy() {
    dialog?.dismiss(); dialog = null  // always dismiss dialogs
    super.onDestroy()
}

// ✓ Symmetric — onStart/onStop, onResume/onPause
override fun onStart() {
    super.onStart()
    registerReceiver(receiver, filter)
    locationManager.requestLocationUpdates(provider, 0, 0f, locationListener)
}
override fun onStop() {
    unregisterReceiver(receiver)
    locationManager.removeUpdates(locationListener)
    super.onStop()
}

// ✓ Better — Lifecycle-aware observer auto-unregisters
lifecycle.addObserver(LocationObserver(locationManager))

// ✗ GlobalScope — never cancelled, outlives Fragment
GlobalScope.launch { val data = repo.fetch(); binding.tv.text = data }

// ✗ collectAsState — keeps collecting even when UI is in background
val state = viewModel.flow.collectAsState()

// ✓ lifecycleScope — cancelled in onDestroy automatically
// ✓ viewLifecycleOwner.lifecycleScope — cancelled in onDestroyView
// ✓ viewModelScope — cancelled in onCleared

override fun onViewCreated(view: View, state: Bundle?) {
    viewLifecycleOwner.lifecycleScope.launch {
        repeatOnLifecycle(Lifecycle.State.STARTED) {
            viewModel.uiState.collect { render(it) }
        }
    }
}

// ✓ In Compose — lifecycle-aware collection
val state = viewModel.flow.collectAsStateWithLifecycle()

// ✓ Always use an image loading library — Coil, Glide, or Picasso
// They handle: lifecycle-awareness, caching, down-sampling, and recycle
binding.imageView.load(url) {
    crossfade(true)
    size(ViewSizeResolver(binding.imageView))  // auto-samples to view size
}  // Coil: request cancelled when Fragment is destroyed

// ✓ If manual, always clean up in onDetachedFromWindow
override fun onDetachedFromWindow() {
    bitmap?.recycle(); bitmap = null
    super.onDetachedFromWindow()
}

// ✗ DisposableEffect with empty onDispose — listener never removed
DisposableEffect(vm) {
    vm.addListener(listener)
    onDispose { }  // EMPTY — listener lives forever
}

// ✓ Always pair setup with cleanup
DisposableEffect(vm) {
    vm.addListener(listener)
    onDispose { vm.removeListener(listener) }
}

// ✗ collectAsState — keeps collecting in background, wastes CPU
val state = vm.flow.collectAsState()
// ✓ collectAsStateWithLifecycle — stops when UI goes background
val state = vm.flow.collectAsStateWithLifecycle()

// build.gradle.kts — debug only, zero app code needed
debugImplementation("com.squareup.leakcanary:leakcanary-android:2.14")

// What LeakCanary does automatically:
// 1. Hooks ActivityLifecycleCallbacks — watches every Activity
// 2. After onDestroy(), waits 5 seconds
// 3. Creates WeakReference to the Activity
// 4. Forces GC, checks if WeakReference was cleared
// 5. If not cleared → suspected leak → dumps HPROF
// 6. Analyzes heap → finds shortest path from GC root to leaked object
// 7. Shows notification with full reference chain

// Reading a LeakCanary trace:
// ┬──────────────────────────────────────────────────
// │ GC Root: static field AnalyticsManager.INSTANCE
// │                                ↓
// │ AnalyticsManager.context       ↓  ← LEAK SUSPECT
// │                                ↓
// ╰→ MainActivity (5 instances, 48 MB retained)
// ┴──────────────────────────────────────────────────

// Watch custom objects too
override fun onDestroy() {
    super.onDestroy()
    AppWatcher.objectWatcher.expectWeaklyReachable(this, "MyService destroyed")
}